home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / src / exampleCode / GLX / texvol / grafix.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-02  |  16.4 KB  |  608 lines
  1. /*
  2.  * Copyright (C) 1994, Silicon Graphics, Inc.
  3.  * All Rights Reserved.
  4.  *
  5.  * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
  6.  * the contents of this file may not be disclosed to third parties, copied or
  7.  * duplicated in any form, in whole or in part, without the prior written
  8.  * permission of Silicon Graphics, Inc.
  9.  *
  10.  * RESTRICTED RIGHTS LEGEND:
  11.  * Use, duplication or disclosure by the Government is subject to restrictions
  12.  * as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
  13.  * and Computer Software clause at DFARS 252.227-7013, and/or in similar or
  14.  * successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
  15.  * rights reserved under the Copyright Laws of the United States.
  16.  */
  17. /*----------------------------------------------------------------------------
  18.  * 
  19.  * file   : grafix.c 
  20.  * 
  21.  * Author : Yusuf Attarwala
  22.  * Date   : Sep 93
  23.  * 
  24.  *---------------------------------------------------------------------------*/
  25. #include <X11/keysym.h>
  26. #include <strings.h>
  27. #include "Xmincludes.h"
  28. #include "globals_vol.h"
  29.  
  30. #include <Xm/Protocols.h>
  31. #include <X11/StringDefs.h>
  32.  
  33.  
  34. Arg args[40];
  35. int argcnt;
  36.  
  37. static short panning = 0;
  38. static long button1State,button2State,button3State;
  39. static long shiftKeyPress = 0,
  40.             altKeyPress   = 0;
  41. static long dx,dy,curX,curY,oldX,oldY;
  42. static long xPress,yPress,xRelease,yRelease;
  43. extern void doExit();
  44. extern unsigned long packc();
  45.  
  46. void
  47. createGraphics(parent)
  48. Widget parent;
  49. {
  50.     char *c;
  51.     Widget frameD,frameS;
  52.     Widget glwDbuffer,glwSbuffer;
  53.     Widget gf;
  54.  
  55.     static int firstTime = 1;
  56.     void gfxExposeCB(),
  57.          gfxResizeCB(),
  58.      gfxInitCB(),
  59.      gfxInputCB();
  60.          
  61.     Atom xaWmDeleteWindow = XmInternAtom(display,"WM_DELETE_WINDOW",TRUE);
  62.  
  63.     static GLXconfig glxConfigD [] = {
  64.         { GLX_NORMAL, GLX_DOUBLE, TRUE },
  65.         { GLX_NORMAL, GLX_RGB, TRUE },
  66.         { GLX_NORMAL, GLX_ZSIZE, GLX_NOCONFIG },
  67.         { 0, 0, 0 }
  68.     };
  69.  
  70.     static GLXconfig glxConfigS [] = {
  71.         { GLX_NORMAL, GLX_DOUBLE, FALSE },
  72.         { GLX_NORMAL, GLX_RGB, TRUE },
  73.         { GLX_NORMAL, GLX_ZSIZE, GLX_NOCONFIG },
  74.         { 0, 0, 0 }
  75.     };
  76.  
  77.     argcnt = 0;
  78.     if (textureMode == TEXTURE_2D) {
  79.     XtSetArg(args[argcnt],XmNtitle,   "2D Texture Vol Render");argcnt++;
  80.     }
  81.     else {
  82.     XtSetArg(args[argcnt],XmNtitle,   "3D Texture Vol Render");argcnt++;
  83.     }
  84.     XtSetArg(args[argcnt],XmNiconName,"VolTex");argcnt++;
  85.     XtSetArg(args[argcnt],XmNkeyboardFocusPolicy, XmPOINTER);argcnt++;
  86.     XtSetArg(args[argcnt],XmNdeleteResponse,      XmUNMAP);argcnt++;
  87.     XtSetArg(args[argcnt],XmNdefaultPosition,     False);argcnt++;
  88.     XtSetArg(args[argcnt],XmNminWidth,  300);argcnt++;
  89.     XtSetArg(args[argcnt],XmNminAspectX,  1);argcnt++;
  90.     XtSetArg(args[argcnt],XmNminAspectY,  1);argcnt++;
  91.     XtSetArg(args[argcnt],XmNmaxAspectX,  1);argcnt++;
  92.     XtSetArg(args[argcnt],XmNmaxAspectY,  1);argcnt++;
  93.  
  94.  
  95.     gf = XtCreatePopupShell("ui",
  96.                    topLevelShellWidgetClass,parent,args,argcnt);
  97.  
  98.     XmAddWMProtocolCallback(gf,xaWmDeleteWindow,doExit,0);
  99.  
  100.     /* double buffer widget */
  101.     argcnt = 0;
  102.     XtSetArg(args[argcnt], XmNbackground,BlackPixel(display,screen)); argcnt++;
  103.     frameD = XtCreateWidget("frameD", xmFrameWidgetClass,
  104.                              gf, args, argcnt);
  105.  
  106.     XtManageChild(frameD);
  107.  
  108.     argcnt = 0;
  109.     XtSetArg(args[argcnt], GlxNglxConfig, glxConfigD); argcnt++;
  110.     glwDbuffer = XtCreateWidget("gfx", glxMDrawWidgetClass,
  111.                                  frameD, args, argcnt);
  112.     XtManageChild(glwDbuffer);
  113.  
  114.     XtAddCallback(glwDbuffer, GlxNexposeCallback, gfxExposeCB, NULL);
  115.     XtAddCallback(glwDbuffer, GlxNresizeCallback, gfxResizeCB, NULL);
  116.     XtAddCallback(glwDbuffer, GlxNginitCallback,  gfxInitCB,   NULL);
  117.     XtAddCallback(glwDbuffer, GlxNinputCallback,  gfxInputCB,  NULL);
  118.  
  119.     /* default to double buffer */
  120.     glw = glwDbuffer;
  121.     XtManageChild(gf);
  122.  
  123.     /*
  124.     installColormaps(toplevel,glw);
  125.     */
  126.  
  127.     /* single buffer */
  128.     argcnt = 0;
  129.     XtSetArg(args[argcnt], XmNbackground,BlackPixel(display,screen)); argcnt++;
  130.     frameS = XtCreateWidget("frameS", xmFrameWidgetClass,
  131.                                   parent, args, argcnt);
  132.  
  133.     argcnt = 0;
  134.     XtSetArg(args[argcnt], GlxNglxConfig, glxConfigS); argcnt++;
  135.     glwSbuffer = XtCreateWidget("gfx", glxMDrawWidgetClass,
  136.                                  frameS, args, argcnt);
  137.     XtManageChild(glwSbuffer);
  138.     XtAddCallback(glwSbuffer, GlxNexposeCallback, gfxExposeCB, NULL);
  139.     XtAddCallback(glwSbuffer, GlxNresizeCallback, gfxResizeCB, NULL);
  140.     XtAddCallback(glwSbuffer, GlxNginitCallback,  gfxInitCB,   NULL);
  141.     XtAddCallback(glwSbuffer, GlxNinputCallback,  gfxInputCB,  NULL);
  142.  
  143.     /*
  144.     installColormaps(toplevel,glwSbuffer);
  145.     */
  146.  
  147.     if (firstTime) {
  148.         firstTime = 0;
  149.     }
  150.  
  151.  
  152.     GLXwinset(XtDisplay(glw), XtWindow(glw));
  153.  
  154.     setProjView(VIEW_TRANSF);
  155.     setProjView(PROJ_TRANSF);
  156. }
  157.  
  158. void 
  159. gfxExposeCB(w,cd,cbs) 
  160. Widget w;
  161. XtPointer *cd;
  162. GlxDrawCallbackStruct *cbs;
  163. {
  164.     GLXwinset(XtDisplay(w), cbs->window);
  165.     drawScene();
  166. }
  167.  
  168. void
  169. gfxResizeCB(w,cd,draw_struct) 
  170. Widget w;
  171. XtPointer *cd;
  172. GlxDrawCallbackStruct *draw_struct;
  173. {
  174.     if (draw_struct->event != (XEvent *)NULL) {
  175.         window_width  = draw_struct->event->xconfigure.width;
  176.         window_height = draw_struct->event->xconfigure.height;
  177.     }
  178.     else {
  179.         argcnt = 0;
  180.         XtSetArg(args[argcnt], XmNwidth,  &window_width); argcnt++;
  181.         XtSetArg(args[argcnt], XmNheight, &window_height); argcnt++;
  182.         XtGetValues(w,args,argcnt);
  183.     }
  184.  
  185.     computeWorldToScreenRatio();
  186.  
  187.     GLXwinset(XtDisplay(w), draw_struct->window);
  188.     viewport(0, (Screencoord) draw_struct->width-1,
  189.              0, (Screencoord) draw_struct->height-1);
  190.  
  191.     setProjView(VIEW_TRANSF);
  192.     setProjView(PROJ_TRANSF);
  193.     drawScene();
  194.  
  195.  
  196. }
  197.  
  198. void
  199. gfxInitCB(w,cd,cbs) 
  200. Widget w;
  201. XtPointer *cd;
  202. GlxDrawCallbackStruct *cbs;
  203. {
  204.     GLXwinset(XtDisplay(w), cbs->window);
  205.     computeWorldToScreenRatio();
  206.  
  207. }
  208.  
  209. Boolean
  210. trackBallMotion()
  211. {
  212.     setProjView(MODL_TRANSF);
  213.     refresh = 1;
  214.     drawScene();
  215.     return(0);
  216. }
  217.  
  218. void
  219. animation(flag)
  220. int flag;
  221. {
  222.     Boolean trackBallMotion();
  223.     static XtWorkProcId wpid;
  224.  
  225.     if (flag == 0) {
  226.         if (trackBall == 1) XtRemoveWorkProc(wpid);
  227.     trackBall = 0;
  228.     }
  229.     else if (trackBall == 0) {
  230.     trackBall = 1;
  231.     wpid = XtAppAddWorkProc(appContext,trackBallMotion,NULL);
  232.     }
  233. }
  234.  
  235. static int cInd[] = {_X,_X,_Y,_Y,_Z,_Z};
  236. static int sliceInd[] = {1,0,3,2,5,4};
  237.  
  238. void
  239. gfxInputCB(w,cd,draw_struct) 
  240. Widget w;
  241. XtPointer *cd;
  242. XmDrawingAreaCallbackStruct *draw_struct;
  243. {
  244.     static Time oldTime = 0, newTime;
  245.     static short doubleClick = 0;
  246.     static short rubberBandZoom = 0;
  247.     char            string[31];
  248.     XComposeStatus  composeStatus;
  249.     KeySym          keysym;
  250.     float           rl,tb;
  251.  
  252.     switch(draw_struct->event->type) {
  253.     case ButtonPress :
  254.  
  255.         xPress = oldX = curX = draw_struct->event->xbutton.x;
  256.         yPress = oldY = curY = draw_struct->event->xbutton.y;
  257.  
  258.         switch(draw_struct->event->xbutton.button){
  259.         case Button1 :
  260.             button1State = 1;
  261.             newTime = draw_struct->event->xbutton.time;
  262.             if (newTime-oldTime < 500)
  263.                 doubleClick = 1;
  264.             else
  265.                 doubleClick = 0;
  266.             oldTime = newTime;
  267.  
  268.  
  269.             if (degenMode) intoDegenerate();
  270.  
  271.             if (shiftKeyPress) {
  272.                 animation(1);
  273.             }
  274.             else {
  275.                 animation(0);
  276.             }
  277.             if (altKeyPress) {
  278.                 rubberBandZoom = 1;
  279.                 drawScene();
  280.                 drawScene();
  281.                 logicop(LO_XOR);
  282.                 frontbuffer(TRUE);
  283.                 loadmatrix(identity);
  284.                 pushmatrix();
  285.                 loadmatrix(identity);
  286.                 ortho2(0.0,(float)window_width,0.0,(float)window_height);
  287.             }
  288.  
  289.             break;
  290.         case Button2 :
  291.             button2State = 1;
  292.             if (degenMode) intoDegenerate();
  293.             if (!button1State) {
  294.                 panning = TRUE;
  295.             }
  296.             else
  297.                 panning = FALSE;
  298.             break;
  299.         case Button3 :
  300.             button3State = 1;
  301.             break;
  302.         }
  303.         break;
  304.     case ButtonRelease :
  305.  
  306.         xRelease = draw_struct->event->xbutton.x;
  307.         yRelease = draw_struct->event->xbutton.y;
  308.  
  309.         switch(draw_struct->event->xbutton.button){
  310.         case Button1 :
  311.             button1State = 0;
  312.             if (degenMode) outofDegenerate();
  313.             break;
  314.         case Button2 :
  315.             button2State = 0;
  316.             if (degenMode) outofDegenerate();
  317.             break;
  318.         case Button3 :
  319.             button3State = 0;
  320.             break;
  321.         }
  322.         break;
  323.     case MotionNotify :
  324.         dx = oldX - curX;
  325.         dy = oldY - curY;
  326.  
  327.         oldX = curX;
  328.         oldY = curY;
  329.  
  330.         curX = draw_struct->event->xbutton.x;
  331.         curY = draw_struct->event->xbutton.y;
  332.  
  333.     if (rubberBandZoom) {
  334.         RGBcolor(255,255,255);
  335.         move2i(xPress,window_height-yPress);
  336.         draw2i(xPress,window_height-oldY);
  337.         draw2i(oldX,window_height-oldY);
  338.         draw2i(oldX,window_height-yPress);
  339.         draw2i(xPress,window_height-yPress);
  340.  
  341.         move2i(xPress,window_height-yPress);
  342.         draw2i(xPress,window_height-curY);
  343.         draw2i(curX,window_height-curY);
  344.         draw2i(curX,window_height-yPress);
  345.         draw2i(xPress,window_height-yPress);
  346.         break;
  347.     }
  348.         else if (button1State && button2State && panning) {
  349.             rl = dx*x_world_per_pixel;
  350.             tb = dy*y_world_per_pixel;
  351.             left   += rl;
  352.             right  += rl;
  353.             top    -= tb;
  354.             bottom -= tb;
  355.             setProjView(PROJ_TRANSF);
  356.         }
  357.         else if (button1State) {
  358.             if (button2State) {
  359.                 anglez = (abs(dx) >= abs(dy)) ? dx : dy;
  360.             }
  361.             else {
  362.                 if (screenAxes) {
  363.                     anglex = -dy;
  364.                     angley = -dx;
  365.                 }
  366.                 else {
  367.                     if (abs(dx) >= abs(dy)) {
  368.                         anglex = dx;
  369.                     }
  370.                     else {
  371.                         angley = -dy;
  372.                     }
  373.                 }
  374.             }
  375.             setProjView(MODL_TRANSF);
  376.         }
  377.         else if (button2State) {
  378.             /* zooming */
  379.             rl = (abs(dx) >= abs(dy)) ? dx*x_world_per_pixel :
  380.                                         dy*y_world_per_pixel ;
  381.             left   -= rl;
  382.             right  += rl;
  383.             tb = rl/world_aspect;
  384.             top    += tb;
  385.             bottom -= tb;
  386.  
  387.             if (left >= right) {
  388.                 left   += rl;
  389.                 right  -= rl;
  390.                 top    -= tb;
  391.                 bottom += tb;
  392.             }
  393.             else
  394.                 setProjView(PROJ_TRANSF);
  395.  
  396.         }
  397.         refresh = 1;
  398.         drawScene();
  399.         break;
  400.     case KeyPress :
  401.         XLookupString(draw_struct->event,string,
  402.                       30,&keysym,&composeStatus);
  403.  
  404.         switch(keysym) {
  405.         case XK_Shift_L :
  406.         case XK_Shift_R :
  407.             shiftKeyPress = 1;
  408.             break;
  409.         case XK_Alt_L :
  410.         case XK_Alt_R :
  411.             altKeyPress = 1;
  412.             break;
  413.         }
  414.         break;
  415.     case KeyRelease :
  416.         XLookupString(draw_struct->event,string,
  417.                       30,&keysym,&composeStatus);
  418.  
  419.         switch(keysym) {
  420.     case XK_a :
  421.         if (cpackAlpha > 0xff) {
  422.         XBell(display,25);
  423.         cpackAlpha = 0xff;
  424.         }
  425.         cpackAlpha += 1;
  426.         cpackValue = packc(cpackAlpha,cpackBlue,cpackGreen,cpackRed);
  427.         drawScene();
  428.         break;
  429.     case XK_b :
  430.         cpackAlpha -= 1;
  431.         if (cpackAlpha < 0) {
  432.         XBell(display,25);
  433.         cpackAlpha = 0;
  434.         }
  435.         cpackValue = packc(cpackAlpha,cpackBlue,cpackGreen,cpackRed);
  436.         drawScene();
  437.         break;
  438.     case XK_o :
  439.             obliquePlaneToggle();
  440.             drawScene();
  441.         break;
  442.     case XK_r :
  443.         resetView();
  444.         break;
  445.         case XK_Shift_L :
  446.         case XK_Shift_R :
  447.             shiftKeyPress = 0;
  448.             break;
  449.         case XK_Alt_L :
  450.         case XK_Alt_R :
  451.             altKeyPress = 0;
  452.             break;
  453.         case XK_F1 :
  454.             if (fog) {fogMode      = FG_VTX_EXP;defFog();}
  455.             drawScene();
  456.             break;
  457.         case XK_F2 :
  458.             if (fog) {fogMode      = FG_PIX_EXP;defFog();}
  459.             drawScene();
  460.             break;
  461.         case XK_F3 :
  462.             if (fog) {fogMode      = FG_VTX_EXP2;defFog();}
  463.             drawScene();
  464.             break;
  465.         case XK_F4 :
  466.             if (fog) {fogMode      = FG_PIX_EXP2;defFog();}
  467.             drawScene();
  468.             break;
  469.         case XK_F5 :
  470.             if (fog) {fogMode      = FG_VTX_LIN;defFog();}
  471.             drawScene();
  472.             break;
  473.         case XK_F6 :
  474.             if (fog) {fogMode      = FG_PIX_LIN;defFog();}
  475.             drawScene();
  476.             break;
  477.  
  478.         case XK_F9 :
  479.             lockAView = 1;
  480.             drawScene();
  481.             break;
  482.         case XK_F10 :
  483.             lockAView = 2;
  484.             drawScene();
  485.             break;
  486.         case XK_F11 :
  487.             lockAView = 3;
  488.             drawScene();
  489.             break;
  490.         case XK_F12 :
  491.             lockAView = 0;
  492.             drawScene();
  493.             break;
  494.  
  495.         case XK_Escape :
  496.         doExit();
  497.             break;
  498.     case XK_Up :
  499.         case XK_Down :
  500.             if (!doClipping) break;
  501.         if (activeClipPlane < 0 || activeClipPlane > 5) break;
  502.         if (keysym == XK_Up) {
  503.         clip[activeClipPlane].xyz[cInd[activeClipPlane]] += 0.35;
  504.  
  505.         /* check the limits */
  506.         if (clip[activeClipPlane].xyz[cInd[activeClipPlane]] > 
  507.             clip[activeClipPlane].max) {
  508.                     XBell(display,25);
  509.             clip[activeClipPlane].xyz[cInd[activeClipPlane]] -= 0.35;
  510.             break;
  511.         }
  512.                 if (moveSlice) {
  513.                     clip[sliceInd[activeClipPlane]].xyz[cInd[activeClipPlane]] 
  514.                     += 0.35;
  515.  
  516.             if (clip[sliceInd[activeClipPlane]].xyz[cInd[activeClipPlane]] > 
  517.             clip[sliceInd[activeClipPlane]].max) {
  518.                         XBell(display,25);
  519.             clip[sliceInd[activeClipPlane]].xyz[cInd[activeClipPlane]] 
  520.             -= 0.35;
  521.  
  522.             clip[activeClipPlane].xyz[cInd[activeClipPlane]] -= 0.35;
  523.             break;
  524.                     }
  525.                 }
  526.  
  527.         }
  528.         else {
  529.         clip[activeClipPlane].xyz[cInd[activeClipPlane]] -= 0.35;
  530.         /* check the limits */
  531.         if (clip[activeClipPlane].xyz[cInd[activeClipPlane]] < 
  532.             clip[activeClipPlane].min) {
  533.                     XBell(display,25);
  534.             clip[activeClipPlane].xyz[cInd[activeClipPlane]] += 0.35;
  535.             break;
  536.         }
  537.                 if (moveSlice) {
  538.                     clip[sliceInd[activeClipPlane]].xyz[cInd[activeClipPlane]] 
  539.                     -= 0.35;
  540.  
  541.             if (clip[sliceInd[activeClipPlane]].xyz[cInd[activeClipPlane]] < 
  542.             clip[sliceInd[activeClipPlane]].min) {
  543.                         XBell(display,25);
  544.             clip[sliceInd[activeClipPlane]].xyz[cInd[activeClipPlane]] 
  545.             += 0.35;
  546.  
  547.             clip[activeClipPlane].xyz[cInd[activeClipPlane]] += 0.35;
  548.             break;
  549.                     }
  550.                 }
  551.         }
  552.         clip[activeClipPlane].coeff[3] = -(
  553.         clip[activeClipPlane].coeff[0]*clip[activeClipPlane].xyz[_X] +
  554.         clip[activeClipPlane].coeff[1]*clip[activeClipPlane].xyz[_Y] +
  555.         clip[activeClipPlane].coeff[2]*clip[activeClipPlane].xyz[_Z] );
  556.  
  557.             if (moveSlice) {
  558.                 clip[sliceInd[activeClipPlane]].coeff[3] = -(
  559.                 clip[sliceInd[activeClipPlane]].coeff[0]*clip[sliceInd[activeClipPlane]].xyz[_X] +
  560.                 clip[sliceInd[activeClipPlane]].coeff[1]*clip[sliceInd[activeClipPlane]].xyz[_Y] +
  561.                 clip[sliceInd[activeClipPlane]].coeff[2]*clip[sliceInd[activeClipPlane]].xyz[_Z] );
  562.             }
  563.  
  564.         refresh = 1;
  565.             drawScene();
  566.         break;
  567.     case XK_Right :
  568.             if (fog) {
  569.                 fogDensity += 0.0001; 
  570.         if (fogDensity > 1.0) {
  571.             XBell(display,25);
  572.             fogDensity = 1.0;
  573.         }
  574.         defFog();
  575.             }
  576.             else if (lightWeight) {
  577.                 lightWeightCount += 1;
  578.                 if (lightWeightCount > 10) {
  579.             XBell(display,25);
  580.             lightWeightCount = 10;
  581.                 }
  582.             }
  583.             drawScene();
  584.         break;
  585.         case XK_Left :
  586.             if (fog) {
  587.                 fogDensity -= 0.0001; 
  588.         if (fogDensity < 0.0) {
  589.             XBell(display,25);
  590.             fogDensity = 0.0;
  591.         }
  592.         defFog();
  593.             }
  594.             if (lightWeight) {
  595.                 lightWeightCount -= 1;
  596.                 if (lightWeightCount < 1) {
  597.             XBell(display,25);
  598.             lightWeightCount = 1;
  599.                 }
  600.             }
  601.             drawScene();
  602.         break;
  603.         default :
  604.             break;
  605.         }
  606.     }
  607. }
  608.